const int systemdatamax = 256;
    const int systemcodemax = 5;
    const int systemdatalen = 256;
    const int systemkeylen = 5;

    struct systemdata
    {
        int id;
        wchar_t key[ systemkeylen ];
        wchar_t data[ systemdatalen ];
        systemdata* next;
    };

    static systemdata* sysdata[ systemcodemax ];
    static systemdata* sysdatastart[ systemcodemax ];

        static void errorstep( int cd, String^ Msg )
        {
            if ( cd < 0 )
            {
                //    エラーメッセージを出力
                Application::Exit( );
                return;
            }
            else if ( cd > 0 )
            {
                //    メッセージを出力
                return;
            }
            else
            {
                return;
            }
        }

        static int systemdataalloc(  systemdata** point )
        {
            size_t sysdata = sizeof( systemdata );
            systemdata* ip;
            ip = ( systemdata* )malloc( sysdata );
            if ( ip == NULL ) { errorstep( -1"プログラム用システムデータエリアを確保できません。" ); return -1; }
            *point = ip;
            return 0;
        }

        int systemdatacount( int code )
        {
            systemdata* ip;
            systemdata* ip1;
            int cnt = -1;
            if ( systemcodecheck( code ) < 0 ) return cnt;
            cnt++;
            if ( sysdatastart[ code ] == NULL ) return cnt;
            cnt++;
            ip1 = sysdatastart[ code ];
            do
            {
                ip = ip1->next;
                if ( ip == NULL ) break;
                ip1 = ip;
                cnt++;
            }
            while ( ip1 != NULL || ( cnt <= systemdatamax && cnt > 0 ) );
            return cnt;
        }

        static int systemcodecheck( int code )
        {
            if ( code < 0 ) return -1;
            if ( code >= systemcodemax ) return -2;
            return 0;
        }

        static int systemdatafree1( int code )
        {
            systemdata* ip;
            systemdata* ip1;
            int cnt = -1;
            if ( systemcodecheck( code ) < 0 ) return cnt;
            cnt++;
            if ( sysdatastart[ code ] == NULL )
            {
                sysdata[ code ] = NULL;
                return cnt;
            }
            cnt++;
            ip1 = sysdatastart[ code ];
            sysdatastart[ code ] = NULL;
            do
            {
                ip = ip1->next;
                if ( ip1 != NULL ) free ( ip1 );
                if ( ip == NULL ) break;
                ip1 = ip;
                cnt++;
            }
            while ( ip1 != NULL || ( cnt <= systemdatamax && cnt > 0 ) );
            sysdata[ code ] = NULL;
            return cnt;
        }

        static int systemdatafree( )
        {
            for ( int i = 0; i < systemcodemax; i++ )
            {
                systemdatafree1( i );
            }
            return 0;
        }

        static int systemdatastore1( int code, wchar_t* key, wchar_t* data, int* id )
        {
            systemdata* ip;
            systemdata* ip1;
            int rtn;
            rtn = systemcodecheck( code );
            if ( rtn < 0 )
            {
                errorstep( -1"systemdatastore( 1 ) systemdata store code is maximum or zero over. code = " + code + " max = " + systemcodemax );
                return -1;
            }
            ip1 = sysdatastart[ code ];
            do
            {
                if ( ip1 == NULL ) break;
                if ( ip1->id == *id )
                {
                    ip1->id = *id;
                    wcscpy_s( ip1->key, systemdatalen, key );
                    wcscpy_s( ip1->data, systemdatalen, data );
                    return 0;
                }
                ip1 = ip1->next;
            }
            while ( ip1 != NULL );
            rtn = systemdataalloc( &ip );
            if ( rtn < 0 )
            {
                errorstep( -1"systemdatastore( 4 ) systemdata store memory over." );
                return -4;
            }
            if ( sysdata[ code ] == NULL ) sysdatastart[ code ] = ip; else sysdata[ code ]->next = ip;
            sysdata[ code ] = ip;
            sysdata[ code ]->next = NULL;
            sysdata[ code ]->id = *id;
            wcscpy_s( sysdata[ code ]->key, systemdatalen, key );
            wcscpy_s( sysdata[ code ]->data, systemdatalen, data );
            return 0;
        }

        int systemdataload( int ostype, int code )
        {
            int len;
            int len1 = 2;
            int len2 = 4;
            int count = 0;
            int nshort = len2 + len1 * systemkeylen + len1 * systemdatalen;
            int mshort;
            //array< unsigned char >^ buffer = gcnew array< unsigned char >( nshort );
            array< unsigned char >^ buffer = gcnew array< unsigned char >( nshort );
            wchar_t data[ systemdatalen ];
            wchar_t key[ systemkeylen ];
            int id;
            int i = 0;
            int j;
            int n;
            int m;
            FileStream^ fs;
            if ( systemcodecheck( code ) < 0 ) return -1;
            String^ inifile = chgmojidata1( systemfileread( ostype, code ) );

            if ( ! File::Exists( inifile ) )
            {
                return -2;
            }

            DateTime dt = File::GetLastWriteTime( inifile );
            //if ( dt.Date != DateTime::Now.Date )
            //{
            //    return -3;
            //}
            try
            {
                fs = File::OpenRead( inifile );
            }
            catch ( System::Exception^ )
            {
                return -4;
            }
            do
            {
                mshort = fs->Read( buffer, count, nshort );
                if ( mshort == nshort )
                {
                    m = 0;
                    len = len2;
                    id = System::BitConverter::ToInt32( buffer, m );
                    m += len;
                    len = len1;
                    for ( j = 0; j < systemkeylen; j++ ) { key[ j ] = System::BitConverter::ToChar( buffer, m ); m += len; }
                    for ( j = 0; j < systemdatalen; j++ ) { data[ j ] = System::BitConverter::ToChar( buffer, m ); m += len; }
                    n = systemdatastore( code, key, data, &id );
                    Trace::WriteLineIf( debugflg, " systemdataload( 4 ) record read and memory store. i = " + i + " code = " + code + " key = " + chgmojidata1( key ) + " data = " + chgmojidata1( data ) );
                }
                else
                {
                    break;
                }
            }
            while ( n >= 0 );
            delete ( IDisposable^ ) fs;
            Trace::WriteLineIf( debugflg, " systemdataload( 5 ) systemdataloaded. read recoad = " + i + " items." );
            return i;
        }

        int systemdatasave( int ostype, int code )
        {
            int cnt;
            int len;
            int len1 = 2;
            int len2 = 4;
            int count = 0;
            int nshort = len2 + len1 * systemkeylen + len1 * systemdatalen;
            array< unsigned char >^ buffer = gcnew array< unsigned char >( nshort );
            array< unsigned char >^ bytework;
            String^ null = "";
            wchar_t data[ systemdatalen ];
            wchar_t key[ systemkeylen ];
            int id;
            int i = 0;
            int j;
            int n;
            int m;
            int ib;
            FileStream^ fs;
            if ( systemcodecheck( code ) < 0 ) return -1;
            String^ inifile = chgmojidata1( systemfileread( ostype, code ) );
            cnt = systemdatacount( code );
            if ( cnt < 1 ) return -1;
            sysdata[ code ] = sysdatastart[ code ];
            fs = File::Create( inifile );
            do
            {
                n = systemdataread( code, &id, key, data );
                if ( n < 0 || i > cnt ) break;
                ib = 0;
                len = len2;
                bytework = System::BitConverter::GetBytes( id );
                for ( m = 0; m < len; m++ ) { buffer[ ib ] = bytework[ m ]; ib += 1; }
                len = len1;
                for ( j = 0; j < systemkeylen; j++ )
                {
                    bytework = System::BitConverter::GetBytes( key[ j] );
                    for ( m = 0; m < len; m++ ) { buffer[ ib ] = bytework[ m ]; ib += 1; }
                }
                for ( j = 0; j < systemdatalen; j++ )
                {
                    bytework = System::BitConverter::GetBytes( data[ j] );
                    for ( m = 0; m < len; m++ ) { buffer[ ib ] = bytework[ m ]; ib += 1; }
                }
                fs->Write( buffer, count, nshort );
                Trace::WriteLineIf( debugflg, " systemdatasave( 1 ) " + i + " code = " + code + " recoard wright. wright data = " + chgmojidata1( data ) );
            }
            while ( n >= 0 || ( i > 0 && i < cnt ) );
            delete( IDisposable^ ) fs;
            File::SetLastWriteTime( inifile, DateTime::Now );
            Trace::WriteLineIf( debugflg, " systemdatasave( 2 ) inifile = " + inifile + " saved. " + i + " record wright. Last Wright Time = " + DateTime::Now );
            return 0;
        }

        int systemdataread( int code, int* id, wchar_t* key, wchar_t* data )
        {
            int rtn;
            rtn = systemcodecheck( code );
            if ( rtn < 0 )
            {
                errorstep( -1"systemdatastore( 1 ) systemdata read code is maximum or zero over. code = " + code + " max = " + systemcodemax );
                return -1;
            }
            if ( sysdata[ code ] == NULL )
            {
                errorstep( -1"systemdatastore( 2 ) systemdata read data not found." );
                return -2;
            }
            *id = sysdata[ code ]->id;
            wcscpy_s( key, systemdatalen, sysdata[ code ]->key );
            wcscpy_s( data, systemdatalen, sysdata[ code ]->data );
            sysdata[ code ] = sysdata[ code ]->next;
            return 0;
        }

        int systemdatasel( int code, int* id, wchar_t* key, wchar_t* data )
        {
            systemdata* ip;
            systemdata* ip1;
            int rtn = systemcodecheck( code );
            if ( rtn < 0 )
            {
                errorstep( -1"systemdatasel( 1 ) systemdata select code is maximum or zero over. code = " + code + " max = " + systemcodemax );
                return -1;
            }
            if ( sysdatastart[ code ] == NULL ) return 0;
            ip = sysdatastart[ code ];
            int cnt = 1;
            do
            {
                ip1 = ip->next;
                if ( wcscmp( key, ip->key ) == 0 )
                {
                    *id = ip->id;
                    wcscpy_s( data, systemdatalen, ip->data );
                    return cnt;
                }
                if ( ip1 == NULL ) break;
                ip = ip1;
                cnt++;
            }
            while ( ip != NULL || ( cnt <= systemdatamax && cnt > 1 ) );
            ( *id ) = -1;
            key[ 0 ] = NULL;
            data[ 0 ] = NULL;
            return -3;
        }

        int systemdatasel1( int code, int* id, wchar_t* key, wchar_t* data )
        {
            systemdata* ip;
            systemdata* ip1;
            int rtn = systemcodecheck( code );
            if ( rtn < 0 )
            {
                errorstep( -1"systemdatasel1( 1 ) systemdata select code is maximum or zero over. code = " + code + " max = " + systemcodemax );
                return -1;
            }
            if ( sysdatastart[ code ] == NULL )
            {
                errorstep( 1"systemdatasel1( 2 ) systemdata select data not  found." );
                return -2;
            }
            ip = sysdatastart[ code ];
            int cnt;
            do
            {
                ip1 = ip->next;
                cnt = ip->id;
                if ( *id == ip->id )
                {
                    *id = ip->id;
                    wcscpy_s( key, systemdatalen, ip->key );
                    wcscpy_s( data, systemdatalen, ip->data );
                    return cnt;
                }
                if ( ip1 == NULL ) break;
                ip = ip1;
            }
            while ( ip != NULL || ( cnt < systemdatamax && cnt >= 0 ) );
            ( *id ) = -1;
            key[ 0 ] = NULL;
            data[ 0 ] = NULL;
            return -2;
        }

        int systemdatapick( wchar_t* key, wchar_t* data, wchar_t* pickdata )
        {
            wchar_t chrswk[ systemdatalen ];
            wchar_t pickwk[ systemdatalen ];
            wchar_t str = L',';
            wchar_t* pdest;
            int i;
            int m;
            m = wcslen( data );
            if ( m <= 0 ) return -1;
            wcscpy_s( chrswk, systemdatalen, data );
            do
            {
                pdest = wcschr( chrswk, str );
                if ( pdest == NULL ) return -2;
                i = ( int )( pdest - chrswk );
                if ( i <= 0 || i > m ) return -3;
                wcsncpy_s( pickwk, systemdatalen, chrswk, i );
                if ( wcscmp( pickwk, key ) == 0 )
                {
                    wcscpy_s( chrswk, systemdatalen, pdest + 1 );
                    pdest = wcschr( chrswk, str );
                    if ( pdest == NULL )
                    {
                        wcscpy_s( pickwk, systemdatalen, chrswk );
                    }
                    else
                    {
                        i = ( int )( pdest - chrswk );
                        if ( i <= 0 || i > m ) return -4;
                        wcsncpy_s( pickwk, systemdatalen, chrswk, i );
                    }
                    if ( wcslen( pickwk ) <= 0 ) return -5;
                    wcscpy_s( pickdata, systemdatalen, pickwk );
                    return 0;
                }
                wcscpy_s( chrswk, systemdatalen, pdest + 1 );
            }
            while ( i > 0 && i <= m );
            return -6;
        }